home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / puma.lha / puma / m2c / puma.c < prev    next >
C/C++ Source or Header  |  1992-09-25  |  20KB  |  643 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Memory
  8. #include "Memory.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_IO
  12. #include "IO.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Strings
  16. #include "Strings.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Idents
  20. #include "Idents.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Sets
  24. #include "Sets.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Errors
  28. #include "Errors.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Scanner
  32. #include "Scanner.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Parser
  36. #include "Parser.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Tree
  40. #include "Tree.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Tree2
  44. #include "Tree2.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Semantics
  48. #include "Semantics.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Optimize
  52. #include "Optimize.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_Mod
  56. #include "Mod.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_C
  60. #include "C.h"
  61. #endif
  62.  
  63. static CHAR DefExtMc [] = ".md";
  64. static CHAR ImpExtMc [] = ".mi";
  65. static CHAR LisExtMc [] = ".imp";
  66. static CHAR DefExtC [] = ".h";
  67. static CHAR ImpExtC [] = ".c";
  68. static Strings_tString PumaLib, TrafoFile, String, PathS;
  69. static struct S_1 {
  70.     CHAR A[255 + 1];
  71. } Argument, PathA;
  72. static SHORTCARD i, j, n;
  73. static CHAR ch;
  74. static Tree_tTree Node;
  75. static IO_tFile SmartOpen ARGS((Strings_tString FileName));
  76. static void SmartClose ARGS((Strings_tString FileName, IO_tFile f));
  77. static void GenerateMacros ARGS(());
  78. static INTEGER IndentLevel;
  79. static void WriteClass ARGS((Tree_tTree t));
  80. static BOOLEAN IsFirst;
  81. static void WritePattern ARGS((Tree_tTree t));
  82.  
  83.  
  84. static IO_tFile SmartOpen
  85. # ifdef __STDC__
  86. (Strings_tString FileName)
  87. # else
  88. (FileName)
  89. Strings_tString FileName;
  90. # endif
  91. {
  92.   Strings_tString PathS;
  93.  
  94.   if (Sets_IsElement(ORD('7'), &Tree_Options)) {
  95.     Strings_ArrayToString((STRING)"yy", 2L, &PathS);
  96.     Strings_Concatenate(&PathS, &FileName);
  97.     Strings_Append(&PathS, '\0');
  98.     Strings_StringToArray(&PathS, PathA.A, 256L);
  99.   } else {
  100.     Strings_Append(&FileName, '\0');
  101.     Strings_StringToArray(&FileName, PathA.A, 256L);
  102.   }
  103.   return IO_WriteOpen(PathA.A, 256L);
  104. }
  105.  
  106. static void SmartClose
  107. # ifdef __STDC__
  108. (Strings_tString FileName, IO_tFile f)
  109. # else
  110. (FileName, f)
  111. Strings_tString FileName;
  112. IO_tFile f;
  113. # endif
  114. {
  115.   Strings_tString PathS;
  116.  
  117.   IO_WriteClose(f);
  118.   if (Sets_IsElement(ORD('7'), &Tree_Options)) {
  119.     Strings_ArrayToString((STRING)"gmdupd ", 7L, &PathS);
  120.     Strings_Concatenate(&PathS, &FileName);
  121.     Strings_ArrayToString((STRING)" yy", 3L, &String);
  122.     Strings_Concatenate(&PathS, &String);
  123.     Strings_Concatenate(&PathS, &FileName);
  124.     Strings_Append(&PathS, '\0');
  125.     Strings_StringToArray(&PathS, PathA.A, 256L);
  126.     n = System(PathA.A, 256L);
  127.   }
  128. }
  129.  
  130. static void GenerateMacros
  131. # ifdef __STDC__
  132. ()
  133. # else
  134. ()
  135. # endif
  136. {
  137.   IO_tFile TypeTabFile;
  138.   Strings_tString s;
  139.   Idents_tIdent i;
  140.   INTEGER j;
  141.  
  142.   if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  143.     Strings_ArrayToString((STRING)"TypeTab.c", 9L, &String);
  144.   } else {
  145.     Strings_ArrayToString((STRING)"TypeTab.m", 9L, &String);
  146.   }
  147.   Strings_Assign(&PathS, &PumaLib);
  148.   Strings_Concatenate(&PathS, &String);
  149.   Strings_Append(&PathS, '\0');
  150.   Strings_StringToArray(&PathS, PathA.A, 256L);
  151.   TypeTabFile = IO_ReadOpen(PathA.A, 256L);
  152.   Strings_ArrayToString((STRING)"yy", 2L, &PathS);
  153.   Idents_GetString(Tree_TreeRoot->U_1.V_26.Spec.TrafoName, &String);
  154.   Strings_Concatenate(&PathS, &String);
  155.   Strings_ArrayToString((STRING)".w", 2L, &String);
  156.   Strings_Concatenate(&PathS, &String);
  157.   Strings_Append(&PathS, '\0');
  158.   Strings_StringToArray(&PathS, PathA.A, 256L);
  159.   Tree_f = IO_WriteOpen(PathA.A, 256L);
  160.   while (!IO_EndOfFile(TypeTabFile)) {
  161.     Strings_ReadL(TypeTabFile, &s);
  162.     i = Idents_MakeIdent(&s);
  163.     if (i <= Semantics_TypeCount && Sets_IsElement((LONGCARD)i, &Semantics_TypeNames)) {
  164.       Sets_Exclude(&Semantics_TypeNames, (LONGCARD)i);
  165.       IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  166.       Tree_WI(i);
  167.       IO_WriteNl(Tree_f);
  168.       Strings_ReadL(TypeTabFile, &s);
  169.       Strings_WriteL(Tree_f, &s);
  170.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  171.       IO_WriteNl(Tree_f);
  172.       for (j = 2; j <= 7; j += 1) {
  173.         IO_ReadNl(TypeTabFile);
  174.       }
  175.       IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  176.       Tree_WI(i);
  177.       IO_WriteNl(Tree_f);
  178.       Strings_ReadL(TypeTabFile, &s);
  179.       Strings_WriteL(Tree_f, &s);
  180.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  181.       IO_WriteNl(Tree_f);
  182.     } else {
  183.       for (j = 1; j <= 8; j += 1) {
  184.         IO_ReadNl(TypeTabFile);
  185.       }
  186.     }
  187.   }
  188.   IO_ReadClose(TypeTabFile);
  189.   Semantics_RemoveTreeTypes(Tree_TreeRoot);
  190.   while (!Sets_IsEmpty(Semantics_TypeNames)) {
  191.     i = Sets_Extract(&Semantics_TypeNames);
  192.     Sets_Include(&Semantics_UserTypes, (LONGCARD)i);
  193.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  194.       IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  195.       Tree_WI(i);
  196.       IO_WriteNl(Tree_f);
  197.       IO_WriteS(Tree_f, (STRING)"# define begin", 14L);
  198.       Tree_WI(i);
  199.       IO_WriteS(Tree_f, (STRING)"(a)", 3L);
  200.       IO_WriteNl(Tree_f);
  201.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  202.       IO_WriteNl(Tree_f);
  203.       IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  204.       Tree_WI(i);
  205.       IO_WriteNl(Tree_f);
  206.       IO_WriteS(Tree_f, (STRING)"# define equal", 14L);
  207.       Tree_WI(i);
  208.       IO_WriteS(Tree_f, (STRING)"(a, b)    memcmp ((char *) & a, (char *) & b, sizeof (a)) == 0", 59L);
  209.       IO_WriteNl(Tree_f);
  210.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  211.       IO_WriteNl(Tree_f);
  212.     } else {
  213.       IO_WriteS(Tree_f, (STRING)"# ifndef begin", 14L);
  214.       Tree_WI(i);
  215.       IO_WriteNl(Tree_f);
  216.       IO_WriteS(Tree_f, (STRING)"# define begin", 14L);
  217.       Tree_WI(i);
  218.       IO_WriteS(Tree_f, (STRING)"(a)", 3L);
  219.       IO_WriteNl(Tree_f);
  220.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  221.       IO_WriteNl(Tree_f);
  222.       IO_WriteS(Tree_f, (STRING)"# ifndef equal", 14L);
  223.       Tree_WI(i);
  224.       IO_WriteNl(Tree_f);
  225.       IO_WriteS(Tree_f, (STRING)"# define equal", 14L);
  226.       Tree_WI(i);
  227.       IO_WriteS(Tree_f, (STRING)"(a, b)    yyIsEqual (a, b)", 23L);
  228.       IO_WriteNl(Tree_f);
  229.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  230.       IO_WriteNl(Tree_f);
  231.     }
  232.   }
  233.   if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  234.     C_MacroC(Tree_TreeRoot);
  235.   } else {
  236.     Mod_MacroMod(Tree_TreeRoot);
  237.   }
  238.   IO_WriteClose(Tree_f);
  239. }
  240.  
  241. static void WriteClass
  242. # ifdef __STDC__
  243. (Tree_tTree t)
  244. # else
  245. (t)
  246. Tree_tTree t;
  247. # endif
  248. {
  249.   INTEGER i;
  250.  
  251.   switch (t->U_1.V_1.Kind) {
  252.   case Tree_Class:;
  253.     {
  254.       register Tree_yClass *W_1 = &t->U_1.V_5.Class;
  255.  
  256.       {
  257.         LONGINT B_1 = 1, B_2 = IndentLevel;
  258.  
  259.         if (B_1 <= B_2)
  260.           for (i = B_1;; i += 1) {
  261.             IO_WriteS((System_tFile)IO_StdOutput, (STRING)"   ", 3L);
  262.             if (i >= B_2) break;
  263.           }
  264.       }
  265.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_1->Name);
  266.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    =", 2L);
  267.       WriteClass(W_1->Attributes);
  268.       if (W_1->Extensions->U_1.V_1.Kind != Tree_NoClass) {
  269.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)" <", 2L);
  270.         IO_WriteNl((System_tFile)IO_StdOutput);
  271.         INC(IndentLevel);
  272.         WriteClass(W_1->Extensions);
  273.         DEC(IndentLevel);
  274.         {
  275.           LONGINT B_3 = 1, B_4 = IndentLevel;
  276.  
  277.           if (B_3 <= B_4)
  278.             for (i = B_3;; i += 1) {
  279.               IO_WriteS((System_tFile)IO_StdOutput, (STRING)"   ", 3L);
  280.               if (i >= B_4) break;
  281.             }
  282.         }
  283.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)">", 1L);
  284.       }
  285.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)" .", 2L);
  286.       IO_WriteNl((System_tFile)IO_StdOutput);
  287.       WriteClass(W_1->Next);
  288.     }
  289.     break;
  290.   case Tree_Child:;
  291.     {
  292.       register Tree_yChild *W_2 = &t->U_1.V_9.Child;
  293.  
  294.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)" ", 1L);
  295.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_2->Name);
  296.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)": ", 2L);
  297.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_2->Type);
  298.       WriteClass(W_2->Next);
  299.     }
  300.     break;
  301.   case Tree_Attribute:;
  302.     {
  303.       register Tree_yAttribute *W_3 = &t->U_1.V_10.Attribute;
  304.  
  305.       if (((SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy)) & W_3->Properties) == 0X0L) {
  306.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)" [", 2L);
  307.         Idents_WriteIdent((System_tFile)IO_StdOutput, W_3->Name);
  308.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)": ", 2L);
  309.         Idents_WriteIdent((System_tFile)IO_StdOutput, W_3->Type);
  310.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"]", 1L);
  311.       }
  312.       WriteClass(W_3->Next);
  313.     }
  314.     break;
  315.   case Tree_ActionPart:;
  316.     {
  317.       register Tree_yActionPart *W_4 = &t->U_1.V_11.ActionPart;
  318.  
  319.       WriteClass(W_4->Next);
  320.     }
  321.     break;
  322.   default :
  323.     break;
  324.   }
  325. }
  326.  
  327. static void WritePattern
  328. # ifdef __STDC__
  329. (Tree_tTree t)
  330. # else
  331. (t)
  332. Tree_tTree t;
  333. # endif
  334. {
  335.   switch (t->U_1.V_1.Kind) {
  336.   case Tree_Class:;
  337.     {
  338.       register Tree_yClass *W_5 = &t->U_1.V_5.Class;
  339.  
  340.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_5->Name);
  341.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)" (", 2L);
  342.       IsFirst = TRUE;
  343.       Tree_ForallAttributes(t, (Tree_ProcOfT)WritePattern);
  344.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)")", 1L);
  345.       IO_WriteNl((System_tFile)IO_StdOutput);
  346.     }
  347.     break;
  348.   case Tree_Child:;
  349.     {
  350.       register Tree_yChild *W_6 = &t->U_1.V_9.Child;
  351.  
  352.       if (IsFirst) {
  353.         IsFirst = FALSE;
  354.       } else {
  355.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)", ", 2L);
  356.       }
  357.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_6->Name);
  358.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)":", 1L);
  359.       Idents_WriteIdent((System_tFile)IO_StdOutput, W_6->Type);
  360.     }
  361.     break;
  362.   case Tree_Attribute:;
  363.     {
  364.       register Tree_yAttribute *W_7 = &t->U_1.V_10.Attribute;
  365.  
  366.       if (((SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy)) & W_7->Properties) == 0X0L) {
  367.         if (IsFirst) {
  368.           IsFirst = FALSE;
  369.         } else {
  370.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)", ", 2L);
  371.         }
  372.         Idents_WriteIdent((System_tFile)IO_StdOutput, W_7->Name);
  373.       }
  374.     }
  375.     break;
  376.   default :
  377.     break;
  378.   }
  379. }
  380.  
  381. void BEGIN_MODULE()
  382. {
  383.   BEGIN_System();
  384.   BEGIN_Memory();
  385.   BEGIN_IO();
  386.   BEGIN_Strings();
  387.   BEGIN_Idents();
  388.   BEGIN_Sets();
  389.   BEGIN_Errors();
  390.   BEGIN_Scanner();
  391.   BEGIN_Parser();
  392.   BEGIN_Tree();
  393.   BEGIN_Tree2();
  394.   BEGIN_Semantics();
  395.   BEGIN_Optimize();
  396.   BEGIN_Mod();
  397.   BEGIN_C();
  398.  
  399.   IndentLevel = 0;
  400.   Strings_AssignEmpty(&PumaLib);
  401.   Tree_SourceFile.A[0] = '\0';
  402.   n = GetArgCount() - 1;
  403.   {
  404.     SHORTCARD B_5 = 1, B_6 = n;
  405.  
  406.     if (B_5 <= B_6)
  407.       for (i = B_5;; i += 1) {
  408.         GetArgument((LONGINT)i, Argument.A, 256L);
  409.         if (Argument.A[0] == '-') {
  410.           if (Argument.A[1] == 'l') {
  411.             Strings_AssignEmpty(&PumaLib);
  412.             j = 2;
  413.             for (;;) {
  414.               ch = Argument.A[j];
  415.               if (ch == '\0') {
  416.                 goto EXIT_1;
  417.               }
  418.               Strings_Append(&PumaLib, ch);
  419.               INC(j);
  420.             } EXIT_1:;
  421.             Strings_Append(&PumaLib, '/');
  422.             DEC(n);
  423.           } else {
  424.             j = 0;
  425.             for (;;) {
  426.               INC(j);
  427.               ch = Argument.A[j];
  428.               if (ch == '\0') {
  429.                 goto EXIT_2;
  430.               } else if (ch == '?') {
  431.                 Sets_Include(&Tree_Options, ORD('h'));
  432.               } else {
  433.                 Sets_Include(&Tree_Options, ORD(ch));
  434.               }
  435.             } EXIT_2:;
  436.           }
  437.         } else if (Argument.A[0] == '?') {
  438.           Sets_Include(&Tree_Options, ORD('h'));
  439.         } else {
  440.           j = 0;
  441.           do {
  442.             ch = Argument.A[j];
  443.             Tree_SourceFile.A[j] = ch;
  444.             INC(j);
  445.           } while (!(ch == '\0'));
  446.           DEC(n);
  447.         }
  448.         if (i >= B_6) break;
  449.       }
  450.   }
  451.   if (n < 1) {
  452.     Sets_Include(&Tree_Options, ORD('a'));
  453.   }
  454.   if (Sets_IsElement(ORD('a'), &Tree_Options)) {
  455.     Sets_Include(&Tree_Options, ORD('d'));
  456.     Sets_Include(&Tree_Options, ORD('i'));
  457.   }
  458.   if (Sets_IsElement(ORD('h'), &Tree_Options)) {
  459.     Sets_Exclude(&Tree_Options, ORD('h'));
  460.     Tree_f = IO_StdOutput;
  461.     IO_WriteNl(Tree_f);
  462.     IO_WriteS(Tree_f, (STRING)"usage: puma [-options] [-ldir] [file]", 37L);
  463.     IO_WriteNl(Tree_f);
  464.     IO_WriteNl(Tree_f);
  465.     IO_WriteS(Tree_f, (STRING)" a generate all, same as -di (default)", 38L);
  466.     IO_WriteNl(Tree_f);
  467.     IO_WriteS(Tree_f, (STRING)" d generate definition     module", 33L);
  468.     IO_WriteNl(Tree_f);
  469.     IO_WriteS(Tree_f, (STRING)" i generate implementation module", 33L);
  470.     IO_WriteNl(Tree_f);
  471.     IO_WriteS(Tree_f, (STRING)" s suppress warnings", 20L);
  472.     IO_WriteNl(Tree_f);
  473.     IO_WriteS(Tree_f, (STRING)" m use procedure MakeTREE to construct nodes (default is inline code)", 69L);
  474.     IO_WriteNl(Tree_f);
  475.     IO_WriteS(Tree_f, (STRING)" p allow node constructors without parentheses", 46L);
  476.     IO_WriteNl(Tree_f);
  477.     IO_WriteS(Tree_f, (STRING)" f signal a runtime error if none of the rules of a procedure matches", 69L);
  478.     IO_WriteNl(Tree_f);
  479.     IO_WriteS(Tree_f, (STRING)" k allow non-linear patterns", 28L);
  480.     IO_WriteNl(Tree_f);
  481.     IO_WriteS(Tree_f, (STRING)" n check parameters for NoTREE (NIL) and treat as failure (tg compatibility)", 76L);
  482.     IO_WriteNl(Tree_f);
  483.     IO_WriteS(Tree_f, (STRING)" w surround actions by WITH statements (tg compatibility)", 57L);
  484.     IO_WriteNl(Tree_f);
  485.     IO_WriteS(Tree_f, (STRING)" e treat undefined names as error", 33L);
  486.     IO_WriteNl(Tree_f);
  487.     IO_WriteS(Tree_f, (STRING)" v treat undefined names as warning", 35L);
  488.     IO_WriteNl(Tree_f);
  489.     IO_WriteS(Tree_f, (STRING)" o list undefined names on standard output", 42L);
  490.     IO_WriteNl(Tree_f);
  491.     IO_WriteS(Tree_f, (STRING)" t print tree definitions", 25L);
  492.     IO_WriteNl(Tree_f);
  493.     IO_WriteS(Tree_f, (STRING)" r print patterns", 17L);
  494.     IO_WriteNl(Tree_f);
  495.     IO_WriteS(Tree_f, (STRING)" q browse internal data structure", 33L);
  496.     IO_WriteNl(Tree_f);
  497.     IO_WriteS(Tree_f, (STRING)" 6 generate # line directives", 29L);
  498.     IO_WriteNl(Tree_f);
  499.     IO_WriteS(Tree_f, (STRING)" 7 touch output files only if necessary", 39L);
  500.     IO_WriteNl(Tree_f);
  501.     IO_WriteS(Tree_f, (STRING)" 8 report storage consumption", 29L);
  502.     IO_WriteNl(Tree_f);
  503.     IO_WriteS(Tree_f, (STRING)" c generate C code (default is Modula-2)", 40L);
  504.     IO_WriteNl(Tree_f);
  505.     IO_WriteS(Tree_f, (STRING)" h print help information", 25L);
  506.     IO_WriteNl(Tree_f);
  507.     IO_WriteS(Tree_f, (STRING)" -ldir specify the directory dir where puma finds its tables", 60L);
  508.     IO_WriteNl(Tree_f);
  509.     IO_WriteNl(Tree_f);
  510.   }
  511.   if (Sets_IsEmpty(Tree_Options)) {
  512.     IO_CloseIO();
  513.     exit(1);
  514.   }
  515.   Strings_ArrayToString(Scanner_ScanTabName.A, 128L, &String);
  516.   Strings_Assign(&PathS, &PumaLib);
  517.   Strings_Concatenate(&PathS, &String);
  518.   Strings_Append(&PathS, '\0');
  519.   Strings_StringToArray(&PathS, Scanner_ScanTabName.A, 128L);
  520.   Strings_ArrayToString(Parser_ParsTabName.A, 129L, &String);
  521.   Strings_Assign(&PathS, &PumaLib);
  522.   Strings_Concatenate(&PathS, &String);
  523.   Strings_Append(&PathS, '\0');
  524.   Strings_StringToArray(&PathS, Parser_ParsTabName.A, 129L);
  525.   Errors_StoreMessages(TRUE);
  526.   if (Tree_SourceFile.A[0] != '\0') {
  527.     Scanner_BeginFile(Tree_SourceFile.A, 256L);
  528.   }
  529.   INC1(Tree_ErrorCount, Parser_Parser());
  530.   Node = Tree_TreeRoot->U_1.V_26.Spec.TreeNames;
  531.   while (Node->U_1.V_1.Kind == Tree_TreeName) {
  532.     Idents_GetString(Node->U_1.V_29.TreeName.Name, &PathS);
  533.     Strings_ArrayToString((STRING)".TS", 3L, &String);
  534.     Strings_Concatenate(&PathS, &String);
  535.     Strings_Append(&PathS, '\0');
  536.     Strings_StringToArray(&PathS, PathA.A, 256L);
  537.     Tree_f = IO_ReadOpen(PathA.A, 256L);
  538.     if (Tree_f >= 0) {
  539.       Strings_ReadL(Tree_f, &String);
  540.       Node->U_1.V_29.TreeName.Name = Idents_MakeIdent(&String);
  541.       Node->U_1.V_29.TreeName.Classes = Tree2_GetTree2(Tree_f);
  542.       IO_ReadClose(Tree_f);
  543.       if (Sets_IsElement(ORD('t'), &Tree_Options)) {
  544.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Tree Definition: ", 17L);
  545.         Idents_WriteIdent((System_tFile)IO_StdOutput, Node->U_1.V_29.TreeName.Name);
  546.         IO_WriteNl((System_tFile)IO_StdOutput);
  547.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"----------------", 16L);
  548.         IO_WriteNl((System_tFile)IO_StdOutput);
  549.         IO_WriteNl((System_tFile)IO_StdOutput);
  550.         WriteClass(Node->U_1.V_29.TreeName.Classes);
  551.         IO_WriteNl((System_tFile)IO_StdOutput);
  552.       }
  553.       if (Sets_IsElement(ORD('r'), &Tree_Options)) {
  554.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Patterns: ", 10L);
  555.         Idents_WriteIdent((System_tFile)IO_StdOutput, Node->U_1.V_29.TreeName.Name);
  556.         IO_WriteNl((System_tFile)IO_StdOutput);
  557.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"---------", 9L);
  558.         IO_WriteNl((System_tFile)IO_StdOutput);
  559.         IO_WriteNl((System_tFile)IO_StdOutput);
  560.         Tree_ForallClasses(Node->U_1.V_29.TreeName.Classes, (Tree_ProcOfT)WritePattern);
  561.         IO_WriteNl((System_tFile)IO_StdOutput);
  562.       }
  563.     } else {
  564.       Node->U_1.V_29.TreeName.Classes = Tree_mNoClass();
  565.       Scanner_ErrorI((STRING)"cannot read view file", 21L, Node->U_1.V_29.TreeName.Pos, Node->U_1.V_29.TreeName.Name);
  566.     }
  567.     Node = Node->U_1.V_29.TreeName.Next;
  568.   }
  569.   Semantics_Semantics(Tree_TreeRoot);
  570.   if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  571.     Optimize_RuleProperties(Tree_TreeRoot);
  572.   } else {
  573.     Optimize_Optimize(Tree_TreeRoot);
  574.   }
  575.   Errors_WriteMessages((System_tFile)IO_StdError);
  576.   if (Sets_IsElement(ORD('q'), &Tree_Options)) {
  577.     Tree_QueryTree(Tree_TreeRoot);
  578.   }
  579.   if (Tree_ErrorCount > 0) {
  580.     IO_CloseIO();
  581.     Exit(1L);
  582.   }
  583.   GenerateMacros();
  584.   if (Sets_IsElement(ORD('d'), &Tree_Options)) {
  585.     Idents_GetString(Tree_TreeRoot->U_1.V_26.Spec.TrafoName, &PathS);
  586.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  587.       Strings_ArrayToString(DefExtC, 2L, &String);
  588.     } else {
  589.       Strings_ArrayToString(DefExtMc, 3L, &String);
  590.     }
  591.     Strings_Concatenate(&PathS, &String);
  592.     Tree_f = SmartOpen(PathS);
  593.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  594.       C_DefC(Tree_TreeRoot);
  595.     } else {
  596.       Mod_DefMod(Tree_TreeRoot);
  597.     }
  598.     SmartClose(PathS, Tree_f);
  599.   }
  600.   if (Sets_IsElement(ORD('i'), &Tree_Options)) {
  601.     Idents_GetString(Tree_TreeRoot->U_1.V_26.Spec.TrafoName, &PathS);
  602.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  603.       Strings_ArrayToString(ImpExtC, 2L, &String);
  604.     } else {
  605.       Strings_ArrayToString(ImpExtMc, 3L, &String);
  606.     }
  607.     Strings_Concatenate(&PathS, &String);
  608.     Strings_Assign(&TrafoFile, &PathS);
  609.     Tree_f = SmartOpen(PathS);
  610.     if (Sets_IsElement(ORD('c'), &Tree_Options)) {
  611.       C_ImplC(Tree_TreeRoot);
  612.     } else {
  613.       Mod_ImplMod(Tree_TreeRoot);
  614.     }
  615.     SmartClose(PathS, Tree_f);
  616.     if (!Sets_IsElement(ORD('c'), &Tree_Options)) {
  617.       Strings_ArrayToString((STRING)"gmdcpp ", 7L, &PathS);
  618.       Strings_Concatenate(&PathS, &TrafoFile);
  619.       Strings_Append(&PathS, '\0');
  620.       Strings_StringToArray(&PathS, PathA.A, 256L);
  621.       n = System(PathA.A, 256L);
  622.       Strings_ArrayToString((STRING)"gmdrm yy", 8L, &PathS);
  623.       Idents_GetString(Tree_TreeRoot->U_1.V_26.Spec.TrafoName, &String);
  624.       Strings_Concatenate(&PathS, &String);
  625.       Strings_ArrayToString((STRING)".w", 2L, &String);
  626.       Strings_Concatenate(&PathS, &String);
  627.       Strings_Append(&PathS, '\0');
  628.       Strings_StringToArray(&PathS, PathA.A, 256L);
  629.       n = System(PathA.A, 256L);
  630.     }
  631.   }
  632.   if (Sets_IsElement(ORD('8'), &Tree_Options)) {
  633.     IO_WriteNl((System_tFile)IO_StdError);
  634.     IO_WriteS((System_tFile)IO_StdError, (STRING)"Memory", 6L);
  635.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)Memory_MemoryUsed, 8L);
  636.     IO_WriteS((System_tFile)IO_StdError, (STRING)"  Heap", 6L);
  637.     IO_WriteI((System_tFile)IO_StdError, (LONGINT)Tree_HeapUsed, 8L);
  638.     IO_WriteNl((System_tFile)IO_StdError);
  639.   }
  640.   IO_CloseIO();
  641.   Exit(0L);
  642. }
  643.